import PptxGenJS from 'pptxgenjs';
import { Document, Packer, Paragraph, TextRun, HeadingLevel } from 'docx';
import jsPDF from 'jspdf';
import 'jspdf-autotable'; // 确保引入autotable插件

// 导入中文字体数据
// 注意：此处应导入真实的字体文件数据
// 实际应用中需替换为正确的字体文件路径或使用base64编码的字体数据
import simheiFontData from './fonts/simhei.ttf';

// 验证字体数据是否加载成功
console.log('字体数据加载状态:', simheiFontData && simheiFontData.length > 0);

// 为PDF添加中文字体支持
const addFontsToPDF = (pdf) => {
  try {
    // 确保字体数据存在
    if (simheiFontData && simheiFontData.length > 0) {
      console.log('字体数据长度:', simheiFontData.length);
      // 检查字体数据是否是有效的base64编码
      const isBase64 = /^([A-Za-z0-9+/]{4})*([A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{2}==)?$/.test(simheiFontData);
      console.log('字体数据是否为有效的base64编码:', isBase64);
      
      pdf.addFileToVFS('simhei.ttf', simheiFontData);
      pdf.addFont('simhei.ttf', 'simhei', 'normal');
      // 验证字体是否成功添加
      const availableFonts = pdf.getFontList();
      console.log('可用字体:', availableFonts);
      if (availableFonts.includes('simhei')) {
        pdf.setFont('simhei');
        console.log('中文字体添加成功并设置为当前字体');
      } else {
        console.warn('字体添加失败，未在可用字体列表中找到simhei');
        // 尝试使用其他方式设置字体
        pdf.setFont('simhei', 'normal');
        console.log('尝试直接设置simhei字体');
      }
    } else {
      console.warn('字体数据为空，无法添加中文字体支持');
      // 如果没有中文字体，尝试使用默认字体
      pdf.setFont('helvetica');
    }
  } catch (error) {
    console.error('添加字体失败:', error);
    // 出错时也使用默认字体
    pdf.setFont('helvetica');
  }
  return pdf;
};

// 处理PPT导出的辅助函数
const handlePPTExport = async (pptx) => {
  try {
    // 检查pptxgenjs版本和API
    if (typeof pptx.exportBlob === 'function') {
      return await pptx.exportBlob();
    } else if (typeof pptx.writeFile === 'function') {
      // 对于旧版本API的兼容处理
      return new Promise((resolve, reject) => {
        pptx.writeFile({ outputType: 'blob' }, (blob) => {
          if (blob) resolve(blob);
          else reject(new Error('Failed to generate PPT blob'));
        });
      });
    } else {
      throw new Error('不支持的pptxgenjs版本，无法导出PPT');
    }
  } catch (error) {
    console.error('PPT导出处理失败:', error);
    throw error;
  }
};

class DocumentConverter {
  /**
   * 处理输入数据，支持纯文本和JSON对象
   * @param {string|Object} input - 输入数据
   * @returns {Object} 标准化后的数据结构
   */
  normalizeInput(input) {
    // 如果是字符串，按换行符分割成段落
    if (typeof input === 'string') {
      return {
        content: input.split('\n').filter(paragraph => paragraph.trim()).map((paragraph, index) => ({
          title: `段落 ${index + 1}`,
          text: paragraph
        }))
      };
    }
    // 如果是对象但没有content字段，尝试使用整个对象作为content
    else if (typeof input === 'object' && !input.content) {
      return {
        content: [{
          title: '内容摘要',
          text: JSON.stringify(input)
        }]
      };
    }
    // 其他情况直接返回
    return input;
  }

  /**
   * 将大模型结果转换为PPT文档
   * @param {string|Object} input - 大模型返回的数据或文本
   * @param {string} title - PPT标题
   * @returns {Promise<Blob>} - PPT文件的Blob对象
   */
  async convertToPPT(input, title = '大模型结果报告') {
    try {
      const data = this.normalizeInput(input);
      const pptx = new PptxGenJS();
      
      // 添加封面
      const coverSlide = pptx.addSlide();
      coverSlide.addText(title, {
        x: 0, y: 1.5, w: '100%', h: 1.5,
        fontSize: 36, bold: true, align: 'center'
      });
      coverSlide.addText('生成时间: ' + new Date().toLocaleString(), {
        x: 0, y: 5, w: '100%', h: 0.5,
        fontSize: 14, align: 'center'
      });

      // 处理内容
      if (data.content) {
        // 根据内容结构添加幻灯片
        if (Array.isArray(data.content)) {
          data.content.forEach((section, index) => {
            const slide = pptx.addSlide();
            slide.addText(section.title || `部分 ${index + 1}`, {
              x: 0, y: 0.5, w: '100%', h: 0.75,
              fontSize: 24, bold: true
            });

            if (section.text) {
              slide.addText(section.text, {
                x: 0.5, y: 1.5, w: '90%', h: 4,
                fontSize: 16
              });
            }

            // 处理图表数据
            if (section.chartData) {
              // 这里可以添加图表生成逻辑
              slide.addText('图表数据', {
                x: 0.5, y: 3, w: '90%', h: 1,
                fontSize: 16, italic: true
              });
            }
          });
        } else {
          // 如果content不是数组，直接添加到幻灯片
          const slide = pptx.addSlide();
          slide.addText('内容摘要', {
            x: 0, y: 0.5, w: '100%', h: 0.75,
            fontSize: 24, bold: true
          });
          slide.addText(data.content.toString(), {
            x: 0.5, y: 1.5, w: '90%', h: 4,
            fontSize: 16
          });
        }
      }

      // 使用统一的导出处理函数
      const pptxBlob = await handlePPTExport(pptx);
      return pptxBlob;
    } catch (error) {
      console.error('转换为PPT失败:', error);
      throw error;
    }
  }

  /**
   * 将大模型结果转换为Word文档
   * @param {string|Object} input - 大模型返回的数据或文本
   * @param {string} title - 文档标题
   * @returns {Promise<Blob>} - Word文件的Blob对象
   */
  async convertToWord(input, title = '大模型结果报告') {
    try {
      const data = this.normalizeInput(input);
      // 正确初始化Document对象，显式添加sections属性
      const doc = new Document({
        creator: 'AI Chat System',
        title: title,
        description: '大模型结果报告',
        sections: []  // 显式初始化sections为空数组
      });

      // 创建一个section，并配置headers和children
      const section = doc.addSection({
        properties: {},
        headers: {},
        footers: {},
        children: []
      });

      // 添加标题
      section.addParagraph(new Paragraph({
        children: [new TextRun({
          text: title,
          bold: true,
          fontSize: 24,
        })],
        headingLevel: HeadingLevel.TITLE,
        alignment: 'center',
        spacing: { after: 200 },
      }));

      // 添加生成时间
      section.addParagraph(new Paragraph({
        children: [new TextRun({
          text: '生成时间: ' + new Date().toLocaleString(),
          fontSize: 12,
        })],
        alignment: 'right',
        spacing: { after: 400 },
      }));

      // 处理内容
      if (data.content) {
        if (Array.isArray(data.content)) {
          data.content.forEach((item) => {
            // 添加小节标题
            if (item.title) {
              section.addParagraph(new Paragraph({
                children: [new TextRun({
                  text: item.title,
                  bold: true,
                  fontSize: 16,
                })],
                headingLevel: HeadingLevel.HEADING_1,
                spacing: { after: 150 },
              }));
            }

            // 添加小节内容
            if (item.text) {
              section.addParagraph(new Paragraph({
                children: [new TextRun({
                  text: item.text,
                  fontSize: 12,
                })],
                spacing: { after: 200 },
              }));
            }
          });
        } else {
          // 如果content不是数组，直接添加
          section.addParagraph(new Paragraph({
            children: [new TextRun({
              text: data.content.toString(),
              fontSize: 12,
            })],
          }));
        }
      }

      // 文档已经初始化了sections属性，无需再次检查

      // 导出为Blob
      const blob = await Packer.toBlob(doc);
      console.log('Word转换成功');
      return blob;
    } catch (error) {
      console.error('转换为Word失败:', error);
      throw error;
    }
  }

  /**
   * 将大模型结果转换为PDF文档
   * @param {string|Object} input - 大模型返回的数据或文本
   * @param {string} title - 文档标题
   * @returns {Promise<Blob>} - PDF文件的Blob对象
   */
  async convertToPDF(input, title = '大模型结果报告') {
    try {
      const data = this.normalizeInput(input);
      const pdf = new jsPDF();
      // 添加中文字体支持
      addFontsToPDF(pdf);
      let yPosition = 10;

      // 添加标题
      pdf.setFontSize(20);
      pdf.text(title, 10, yPosition);
      yPosition += 10;

      // 添加生成时间
      pdf.setFontSize(10);
      pdf.text('生成时间: ' + new Date().toLocaleString(), 10, yPosition);
      yPosition += 15;

      // 处理内容
      if (data.content) {
        pdf.setFontSize(12);

        if (Array.isArray(data.content)) {
          data.content.forEach((section) => {
            // 添加小节标题
            if (section.title) {
              pdf.setFontSize(14);
              pdf.setFont('bold');
              pdf.text(section.title, 10, yPosition);
              yPosition += 10;
              pdf.setFontSize(12);
              pdf.setFont('normal');
            }

            // 添加小节内容
            if (section.text) {
              // 处理长文本，自动换行
              const lines = pdf.splitTextToSize(section.text, 180);
              pdf.text(lines, 10, yPosition);
              yPosition += lines.length * 7 + 5;
            }
          });
        } else {
          // 如果content不是数组，直接添加
          const lines = pdf.splitTextToSize(data.content.toString(), 180);
          pdf.text(lines, 10, yPosition);
        }
      }

      // 导出为Blob
      return pdf.output('blob');
    } catch (error) {
      console.error('转换为PDF失败:', error);
      throw error;
    }
  }
}

export default DocumentConverter;